#include "unifieddragdrophandler.h"
#include "fileidentitymanager.h"
#include <QDebug>
#include <QMimeData>
UnifiedDragDropHandler::UnifiedDragDropHandler(QWidget* parentWidget, QObject* parent)
    : QObject(parent), m_parentWidget(parentWidget)
{
}
bool UnifiedDragDropHandler::handleDragEnter(QDragEnterEvent* event)
{
    // 检查是否包含文件或目录
    if (!event->mimeData()->hasUrls()) {
        return false;
    }
    QList<QUrl> urls = event->mimeData()->urls();
    if (urls.isEmpty()) {
        return false;
    }
    // 检查是否包含支持的文件或目录
    for (const QUrl& url : urls) {
        QString filePath = url.toLocalFile();
        QFileInfo fileInfo(filePath);
        if (fileInfo.isFile()) {
            if (isSupportedFile(filePath)) {
                event->acceptProposedAction();
                return true;
            }
        } else if (fileInfo.isDir()) {
            // 接受目录（稍后检查内容）
            event->acceptProposedAction();
            return true;
        }
    }
    return false;
}
// === 新增：带重复检测的拖拽处理方法 ===
bool UnifiedDragDropHandler::handleDrop(QDropEvent* event, const FileProcessCallback& callback,
                                        const QList<UnifiedFileInfo>& existingFiles,
                                        DuplicateStrategy strategy)
{
    QList<QUrl> urls = event->mimeData()->urls();
    if (urls.isEmpty()) {
        return false;
    }
    // 提取有效文件路径
    QStringList filePaths = extractValidFilePaths(urls);
    if (filePaths.isEmpty()) {
        if (m_parentWidget) {
            QMessageBox::warning(m_parentWidget,
                QObject::tr("错误"),
                QObject::tr("没有找到支持的图片或PDF文件"));
        }
        return false;
    }
    // 执行重复文件检测
    DragDropResult result = checkForDuplicates(filePaths, existingFiles, strategy);
    // 如果有重复文件且策略是拒绝，直接返回失败
    if (strategy == DuplicateStrategy::Reject && result.hasDuplicates()) {
        if (m_parentWidget) {
            QMessageBox::warning(m_parentWidget,
                QObject::tr("重复文件"),
                QObject::tr("检测到重复文件，已拒绝所有文件。\n重复文件：%1")
                .arg(result.duplicateFiles.join(", ")));
        }
        return false;
    }
    // 回调通知调用方
    if (callback) {
        callback(result);
    }
    event->acceptProposedAction();
    return true;
}
// === 向后兼容的处理方法 ===
bool UnifiedDragDropHandler::handleDropLegacy(QDropEvent* event, const FileProcessCallback& callback)
{
    QList<QUrl> urls = event->mimeData()->urls();
    if (urls.isEmpty()) {
        return false;
    }
    // 提取有效文件路径
    QStringList filePaths = extractValidFilePaths(urls);
    if (filePaths.isEmpty()) {
        if (m_parentWidget) {
            QMessageBox::warning(m_parentWidget,
                QObject::tr("错误"),
                QObject::tr("没有找到支持的图片或PDF文件"));
        }
        return false;
    }
    // 选择主要文件
    QString primaryFile = selectPrimaryFile(filePaths);
    // 构建结果（兼容旧版本，但使用新结构）
    DragDropResult result;
    result.validFiles = filePaths;
    result.primaryFilePath = primaryFile;
    // 回调通知调用方
    if (callback) {
        callback(result);
    }
    event->acceptProposedAction();
    return true;
}
QStringList UnifiedDragDropHandler::extractValidFilePaths(const QList<QUrl>& urls)
{
    QStringList filePaths;
    for (const QUrl& url : urls) {
        QString filePath = url.toLocalFile();
        QFileInfo fileInfo(filePath);
        if (fileInfo.isFile()) {
            // 单个文件
            if (isSupportedFile(filePath)) {
                filePaths.append(filePath);
            }
        } else if (fileInfo.isDir()) {
            // 目录，扫描其中的支持文件
            QStringList dirFiles = scanDirectoryForSupportedFiles(filePath);
            filePaths.append(dirFiles);
        }
    }
    return filePaths;
}
bool UnifiedDragDropHandler::isSupportedFile(const QString& filePath)
{
    QFileInfo fileInfo(filePath);
    QString suffix = fileInfo.suffix().toLower();
    // PDF文件
    if (suffix == "pdf") {
        return true;
    }
    // 图片文件
    QList<QByteArray> supportedFormats = QImageReader::supportedImageFormats();
    return supportedFormats.contains(suffix.toLocal8Bit());
}
QStringList UnifiedDragDropHandler::scanDirectoryForSupportedFiles(const QString& dirPath)
{
    QDir dir(dirPath);
    QStringList filters;
    // 添加支持的图片格式
    QList<QByteArray> imageFormats = QImageReader::supportedImageFormats();
    for (const QByteArray& format : imageFormats) {
        filters << QString("*.%1").arg(QString::fromLocal8Bit(format));
    }
    // 添加PDF格式
    filters << "*.pdf";
    QFileInfoList files = dir.entryInfoList(filters, QDir::Files);
    QStringList filePaths;
    for (const QFileInfo& file : files) {
        filePaths.append(file.absoluteFilePath());
    }
    return filePaths;
}
QString UnifiedDragDropHandler::selectPrimaryFile(const QStringList& filePaths)
{
    if (filePaths.isEmpty()) {
        return QString();
    }
    // 优先选择PDF文件（因为PDF的布局判断更明确）
    for (const QString& filePath : filePaths) {
        if (LayoutStateManager::isPdfFile(filePath)) {
            return filePath;
        }
    }
    // 如果没有PDF，选择第一个文件
    return filePaths.first();
}
// === 新增：重复文件检测实现 ===
UnifiedDragDropHandler::DragDropResult UnifiedDragDropHandler::checkForDuplicates(
    const QStringList& filePaths,
    const QList<UnifiedFileInfo>& existingFiles,
    DuplicateStrategy strategy)
{
    DragDropResult result;
    QSet<QString> existingIdentities;
    // 构建现有文件标识集合
    for (const UnifiedFileInfo& fileInfo : existingFiles) {
        QString identity = FileIdentityManager::getFileIdentity(fileInfo.filePath);
        if (!identity.isEmpty()) {
            existingIdentities.insert(identity);
        }
    }
    // 检测每个文件
    for (const QString& filePath : filePaths) {
        QFileInfo fileInfo(filePath);
        // 检查文件是否存在和可读
        if (!fileInfo.exists() || !fileInfo.isReadable()) {
            result.skippedFiles.append(filePath);
            continue;
        }
        // 生成文件标识
        QString fileIdentity = FileIdentityManager::getFileIdentity(filePath);
        if (fileIdentity.isEmpty()) {
            result.skippedFiles.append(filePath);
            continue;
        }
        // 检查是否与现有文件重复
        if (existingIdentities.contains(fileIdentity)) {
            // 找到重复的现有文件
            QString existingFilePath = findExistingFileByIdentity(fileIdentity, existingFiles);
            result.duplicateFiles.append(filePath);
            result.duplicateMapping[filePath] = existingFilePath;
            // 根据策略处理重复文件
            if (strategy == DuplicateStrategy::ReplaceExisting) {
                result.validFiles.append(filePath);
            }
        } else {
            // 非重复文件
            result.validFiles.append(filePath);
        }
    }
    // 选择主要文件
    if (result.hasValidFiles()) {
        result.primaryFilePath = selectPrimaryFile(result.validFiles);
    } else if (!result.duplicateFiles.isEmpty()) {
        result.primaryFilePath = selectPrimaryFile(result.duplicateFiles);
    }
    return result;
}
bool UnifiedDragDropHandler::isFileAlreadyAdded(const QString& filePath, 
                                               const QList<UnifiedFileInfo>& existingFiles)
{
    QString fileIdentity = FileIdentityManager::getFileIdentity(filePath);
    if (fileIdentity.isEmpty()) {
        return false; // 文件不存在或无法读取
    }
    for (const UnifiedFileInfo& existingFile : existingFiles) {
        QString existingIdentity = FileIdentityManager::getFileIdentity(existingFile.filePath);
        if (existingIdentity == fileIdentity) {
            return true;
        }
    }
    return false;
}
QString UnifiedDragDropHandler::strategyToString(DuplicateStrategy strategy)
{
    switch (strategy) {
        case DuplicateStrategy::Skip:
            return "跳过重复文件";
        case DuplicateStrategy::Reject:
            return "拒绝重复文件";
        case DuplicateStrategy::ReplaceExisting:
            return "替换现有文件";
        case DuplicateStrategy::AskUser:
            return "询问用户";
        default:
            return "未知策略";
    }
}
QString UnifiedDragDropHandler::DragDropResult::generateSummary() const
{
    QStringList summaryParts;
    if (hasValidFiles()) {
        summaryParts << QString("将添加 %1 个新文件").arg(validFiles.size());
    }
    if (hasDuplicates()) {
        summaryParts << QString("发现 %1 个重复文件").arg(duplicateFiles.size());
    }
    if (hasSkippedFiles()) {
        summaryParts << QString("跳过 %1 个文件").arg(skippedFiles.size());
    }
    if (summaryParts.isEmpty()) {
        return "没有文件需要处理";
    }
    return summaryParts.join("，");
}
// === 私有辅助方法 ===
QString UnifiedDragDropHandler::findExistingFileByIdentity(const QString& fileIdentity,
                                                          const QList<UnifiedFileInfo>& existingFiles)
{
    for (const UnifiedFileInfo& existingFile : existingFiles) {
        QString existingIdentity = FileIdentityManager::getFileIdentity(existingFile.filePath);
        if (existingIdentity == fileIdentity) {
            return existingFile.filePath;
        }
    }
    return "未知";
}